Fundamental Drawing Algorithms in Computer Graphics - Chapter 4 - [Part 2]

import math
import pygame
import sys

def draw_circle(screen, center_x, center_y, radius):
    for x in range(center_x - radius, center_x + radius + 1):
        dx = x - center_x
        square_term = radius**2 - dx**2
        if square_term < 0:
            continue
        dy = math.sqrt(square_term)
        y1 = round(center_y - dy)
        y2 = round(center_y + dy)
        screen.set_at((x, y1), (255, 255, 255))
        screen.set_at((x, y2), (255, 255, 255))

pygame.init()
screen = pygame.display.set_mode((500, 500))
pygame.display.set_caption("Circle Demo")
clock = pygame.time.Clock()

running = True
while running:
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False

    screen.fill((0, 0, 0))
    draw_circle(screen, 250, 250, 150)
    pygame.display.flip()
    clock.tick(60)

pygame.quit()
sys.exit()

import pygame
import math

# Constants
WIDTH, HEIGHT = 800, 600
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)
BLUE = (0, 0, 255)  # For octant labels

# Center and radius of the circle
CENTER_X, CENTER_Y = WIDTH // 2, HEIGHT // 2
RADIUS = 250

# Initialize Pygame
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Eight-way Symmetry Example")
screen.fill(WHITE)

# Font for labeling
font = pygame.font.SysFont("Arial", 20)

# 1. Draw the circle using parametric form:
# x = r * cos(theta), y = r * sin(theta)
for theta in range(0, 360):
    rad = math.radians(theta)
    x = CENTER_X + round(RADIUS * math.cos(rad))
    y = CENTER_Y - round(RADIUS * math.sin(rad))
    pygame.draw.circle(screen, BLACK, (x, y), 1)

# 2. Draw octant lines (every 45 degrees)
for i in range(8):
    angle_deg = i * 45
    rad = math.radians(angle_deg)

    end_x = CENTER_X + RADIUS * math.cos(rad)
    end_y = CENTER_Y - RADIUS * math.sin(rad)

    pygame.draw.line(
        screen,
        BLACK,
        (CENTER_X, CENTER_Y),
        (end_x, end_y),
        1
    )

# 3. Octant labels
labels = [
    "Oct1: (x, y)",
    "Oct2: (y, x)",
    "Oct3: (-y, x)",
    "Oct4: (-x, y)",
    "Oct5: (-x, -y)",
    "Oct6: (-y, -x)",
    "Oct7: (y, -x)",
    "Oct8: (x, -y)"
]

for i in range(8):
    angle_deg = i * 45 + 22.5
    rad = math.radians(angle_deg)

    # Place text inside the circle
    label_x = CENTER_X + (RADIUS * 0.7) * math.cos(rad)
    label_y = CENTER_Y - (RADIUS * 0.7) * math.sin(rad)

    text = font.render(labels[i], True, BLUE)
    text_rect = text.get_rect(center=(label_x, label_y))
    screen.blit(text, text_rect)

# Update the display
pygame.display.flip()

# Main loop to keep window open
running = True
while running:
    for event in pygame.event.get():
        if (
            event.type == pygame.QUIT
            or (
                event.type == pygame.KEYDOWN
                and event.key == pygame.K_ESCAPE
            )
        ):
            running = False

pygame.quit()

import pygame
import math

# Function for midpoint circle algorithm to calculate circle points
def midpoint_circle(center_x, center_y, radius):
    x = 0
    y = radius
    decision_param = 1 - radius
    points = []

    # Function to add 8 points for each symmetrical point in octants
    def add_symmetric_points(cx, cy, x, y):
        points.extend([
            (cx + x, cy + y), (cx - x, cy + y),
            (cx + x, cy - y), (cx - x, cy - y),
            (cx + y, cy + x), (cx - y, cy + x),
            (cx + y, cy - x), (cx - y, cy - x)
        ])

    # Add the initial points
    add_symmetric_points(center_x, center_y, x, y)

    # Begin algorithm loop to create circle points incrementally
    while x < y:
        x += 1

        if decision_param < 0:
            decision_param += 2 * x + 1
        else:
            y -= 1
            decision_param += 2 * (x - y) + 1

        # Add next set of symmetrical points
        add_symmetric_points(center_x, center_y, x, y)

    return points

# ==========================================
# Main Execution Block
# ==========================================
if __name__ == "__main__":

    # Initialize Pygame
    pygame.init()

    # Colors
    WHITE = (255, 255, 255)
    BLACK = (0, 0, 0)

    # Logical screen settings
    WIDTH, HEIGHT = 800, 600
    PIXEL_SIZE = 1

    # Circle parameters
    radius = 250
    center = (WIDTH // 2, HEIGHT // 2)

    # Set up display
    screen = pygame.display.set_mode(
        (WIDTH * PIXEL_SIZE, HEIGHT * PIXEL_SIZE)
    )
    pygame.display.set_caption(
        "Circle Drawing Using Midpoint Algorithm"
    )

    # Fill background with white color
    screen.fill(WHITE)

    # Calculate all circle points using the algorithm
    points = midpoint_circle(*center, radius)

    # Draw each generated point
    for x, y in points:
        pygame.draw.rect(
            screen,
            BLACK,
            (
                x * PIXEL_SIZE,
                y * PIXEL_SIZE,
                PIXEL_SIZE,
                PIXEL_SIZE
            )
        )

    # Update display
    pygame.display.flip()

    # Main loop
    running = True
    while running:
        for event in pygame.event.get():
            if (
                event.type == pygame.QUIT
                or (
                    event.type == pygame.KEYDOWN
                    and event.key == pygame.K_ESCAPE
                )
            ):
                running = False

    # Quit Pygame
    pygame.quit()

import pygame

# Function for Bresenham's circle algorithm to calculate circle points
def bresenham_circle(center_x, center_y, radius):
    x = 0
    y = radius
    d = 3 - 2 * radius
    points = []

    # Function to add 8 points for each symmetrical point in octants
    def add_symmetric_points(cx, cy, x, y):
        points.extend([
            (cx + x, cy + y),
            (cx - x, cy + y),
            (cx + x, cy - y),
            (cx - x, cy - y),
            (cx + y, cy + x),
            (cx - y, cy + x),
            (cx + y, cy - x),
            (cx - y, cy - x)
        ])

    # Add the initial symmetric points for (0, radius)
    add_symmetric_points(center_x, center_y, x, y)

    # Begin algorithm loop
    while x <= y:
        x += 1

        if d < 0:
            d = d + 4 * x + 6
        else:
            y -= 1
            d = d + 4 * (x - y) + 10

        # Add next set of symmetrical points
        add_symmetric_points(center_x, center_y, x, y)

    return points

# ==========================================
# Main Execution Block
# ==========================================
if __name__ == "__main__":

    # Colors
    WHITE = (255, 255, 255)
    BLACK = (0, 0, 0)

    # Logical screen settings
    WIDTH, HEIGHT = 80, 60
    PIXEL_SIZE = 10

    # Circle parameters
    radius = 25
    center = (WIDTH // 2, HEIGHT // 2)

    # Initialize Pygame
    pygame.init()

    screen = pygame.display.set_mode(
        (WIDTH * PIXEL_SIZE, HEIGHT * PIXEL_SIZE)
    )
    pygame.display.set_caption(
        "Bresenham's Circle Algorithm"
    )

    # Fill background
    screen.fill(WHITE)

    # Draw the circle points
    points = bresenham_circle(*center, radius)

    # Render the calculated points on screen
    for x, y in points:
        pygame.draw.rect(
            screen,
            BLACK,
            (
                x * PIXEL_SIZE,
                y * PIXEL_SIZE,
                PIXEL_SIZE,
                PIXEL_SIZE
            )
        )

    # Update display
    pygame.display.flip()

    # Main loop
    running = True
    while running:
        for event in pygame.event.get():
            if (
                event.type == pygame.QUIT
                or (
                    event.type == pygame.KEYDOWN
                    and event.key == pygame.K_ESCAPE
                )
            ):
                running = False

    pygame.quit()

import pygame
import math

# ==========================================
# Parametric Circle Drawing Algorithm
# ==========================================

# Initialize Pygame
pygame.init()

screen = pygame.display.set_mode((600, 500))
pygame.display.set_caption(
    "Parametric Circle Drawing Algorithm"
)

# Colors
WHITE = (255, 255, 255)
BLACK = (0, 0, 0)

# Fill background
screen.fill(WHITE)

# Circle parameters
center_x, center_y = 300, 250
radius = 200

# Draw circle using parametric equation
for theta in range(0, 360):

    # Convert degrees to radians
    rad = math.radians(theta)

    # Calculate x and y coordinates
    x = center_x + radius * math.cos(rad)

    # Invert y because screen y increases downward
    y = center_y - radius * math.sin(rad)

    # Plot the pixel
    pygame.draw.circle(
        screen,
        BLACK,
        (round(x), round(y)),
        1
    )

# Update the display
pygame.display.flip()

# Main loop
running = True
while running:
    for event in pygame.event.get():
        if (
            event.type == pygame.QUIT
            or (
                event.type == pygame.KEYDOWN
                and event.key == pygame.K_ESCAPE
            )
        ):
            running = False

# Quit Pygame
pygame.quit()